home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / findpool.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  6.6 KB  |  240 lines
  1. #include "includes.h"
  2.  
  3.  BitMap *FindPool_SampleImg;
  4.  
  5.  
  6.  int GridQuant(float Dist, int Size)
  7.   {
  8.    float s=(float)(Size)/2.0;
  9.    int i=(int)(Dist+s-0.5);
  10.    if (i>=Size) i=Size-1;
  11.    if (i<0)     i=0;
  12.       
  13.    return i;
  14.    
  15.   }
  16.  
  17. /**************************************|****************************************
  18. Routine   :FindNodes3D
  19. Input  par:BitMap3D *Image 
  20.            PoolStructure *Pool,int B,int delta,
  21.                           int FeatureDim,float fTShadeEdge, int domain
  22. Output par:
  23. Function  :
  24. ***************************************|***************************************/
  25.  
  26.  PoolNode ***FindNodes(BitMap *Image,PoolStructure *Pool,int B,int delta,
  27.                        int FeatureDim,float fTShadeEdge, int domain)
  28.   {
  29.    PoolNode ***Array;
  30.    PoolNode *Node;
  31.    float *Features;
  32.    int x,y,XMax,YMax,Count=0;
  33.    
  34.    if (domain) XMax=((Image->XSize<<1)-B)/delta +1;
  35.    else        XMax=(Image->XSize)/B;
  36.    if (domain) YMax=((Image->YSize<<1)-B)/delta +1;
  37.    else        YMax=(Image->YSize)/B;
  38.    
  39.    Array=GimmeAPoolNodeArray(XMax,YMax);
  40.    
  41.    if (domain)
  42.     {
  43.      Pool->DomainX=XMax;
  44.      Pool->DomainY=YMax;
  45.     }
  46.    else
  47.     {
  48.      Pool->RangeX=XMax;
  49.      Pool->RangeY=YMax;
  50.     }
  51.    
  52.    for(x=0;x<XMax;x++)
  53.    for(y=0;y<YMax;y++)
  54.     {
  55.      Array[x][y]=Node=GimmeAPoolNode();
  56.      
  57.      if (domain) Features=Classify(Image,(x*delta)>>1,(y*delta)>>1,
  58.                                    B>>1,FeatureDim,fTShadeEdge);
  59.      else        Features=Classify(Image,x*delta,y*delta,
  60.                                    B,FeatureDim,fTShadeEdge);
  61.      
  62.      Node->Features=Features;
  63.      Node->Distance=NULL;
  64.      
  65.      if (Features[VAR]>fTShadeEdge)  
  66.       {
  67.        Node->x=x*delta;
  68.        Node->y=y*delta;
  69.        Count++;
  70.       }
  71.     }
  72.    
  73.    vprintf(stderr,"block size %3d, edges: %6d total: %6d  = %3.1f%c",B,Count,
  74.            XMax*YMax,Count*100.0/(float)(XMax*YMax),'%');
  75.    
  76.    
  77.    return Array;
  78.   } 
  79.  
  80.  
  81.  FeatureSpace *FindSpace(PoolStructure *Pool,int FeatureDim,int Size,float fTShadeEdge)  
  82.   {
  83.    FeatureSpace *S=GimmeAFeatureSpace(FeatureDim,Size);
  84.    Grid         *Tmp;
  85.    GridTerm     *T;
  86.    PoolNode ***DPool=Pool->DomainNodes;
  87.    PoolNode ***RPool=Pool->RangeNodes;
  88.    PoolNode    *Temp;
  89.    ListNode *TempNode;
  90.    
  91.    float *Count=GimmeAFloatArray(FeatureDim);
  92.    float *Mean =GimmeAFloatArray(FeatureDim);
  93.    float *Var  =GimmeAFloatArray(FeatureDim);
  94.    float *InvDev=GimmeAFloatArray(FeatureDim);
  95.    
  96.    float temp;
  97.    double t;
  98.    register int x,y,i,itemp;
  99.    
  100.    for(i=0;i<FeatureDim;i++)   /* find mean for all (domain) features */
  101.     {
  102.      double mean=0.0,var=0.0;  /* find variance cov_ii for all features */
  103.      Count[i]=0.0;
  104.      for(x=0;x<Pool->DomainX;x++)
  105.      for(y=0;y<Pool->DomainY;y++)
  106.       {
  107.        Temp=DPool[x][y];
  108.        if (Temp!=NULL && Temp->Features[VAR]>fTShadeEdge)
  109.         {
  110.          t=(double)Temp->Features[i+PREDEFFEATURES];
  111.          mean += t;
  112.          var += t*t;
  113.          Count[i]++;
  114.         }
  115.       }
  116.      Mean[i]=(float)(mean/(double)Count[i]);
  117.      t=(var-Count[i]*Mean[i]*Mean[i])/(Count[i]-1.0);
  118.      Var[i]=(float)t;
  119.      InvDev[i]=1.0/(float)sqrt(t);
  120.     }
  121.    
  122.    for(x=0;x<Pool->DomainX;x++) /* insert domain blocks in feature grid */
  123.    for(y=0;y<Pool->DomainY;y++) /* using Mahalanobis distance    */
  124.     {
  125.      Temp=DPool[x][y];
  126.      if (Temp!=NULL && Temp->Features[VAR]>fTShadeEdge)
  127.       {
  128.        Temp->Distance=GimmeALongArray(FeatureDim);
  129.        Temp->Index   =GimmeAIntArray(FeatureDim);
  130.        Tmp=S->GridArray;
  131.        for(i=0;i<FeatureDim;i++)
  132.         {
  133.          temp=(Temp->Features[i+PREDEFFEATURES]-Mean[i])*InvDev[i];
  134.          Temp->Distance[i]=(long)(temp*F2LONG);
  135.          itemp=GridQuant(temp,Size);
  136.          Temp->Index[i] = itemp;
  137.          Tmp=Tmp->Next[itemp];
  138.         }
  139.        
  140.        T=(GridTerm *)Tmp;
  141.        if (T->Class==NULL)
  142.         {
  143.          T->Class=GimmeAListNode();
  144.          TempNode=T->Class;
  145.         }
  146.        else
  147.         {
  148.          TempNode=T->Class;
  149.          while (TempNode->Next!=NULL) TempNode=TempNode->Next;
  150.          
  151.          TempNode->Next=GimmeAListNode();
  152.          TempNode=TempNode->Next;
  153.         }
  154.        
  155.        TempNode->Domain=Temp;
  156.        T->Count++;
  157.       }
  158.     }
  159.    
  160.    for(x=0;x<Pool->RangeX;x++) /* insert range blocks in feature grid */
  161.    for(y=0;y<Pool->RangeY;y++) /* using Mahalanobis distance    */
  162.     {
  163.      Temp=RPool[x][y];
  164.      if (Temp->Features[VAR]>fTShadeEdge)
  165.       {
  166.        Temp->Distance=GimmeALongArray(FeatureDim);
  167.        Temp->Index   =GimmeAIntArray(FeatureDim);
  168.        for(i=0;i<FeatureDim;i++)
  169.         {
  170.          temp=(Temp->Features[i+PREDEFFEATURES]-Mean[i])*InvDev[i];
  171.          Temp->Distance[i]=(long)(temp*F2LONG);
  172.          itemp=GridQuant(temp,Size);
  173.          Temp->Index[i]=itemp;
  174.         }
  175.       }
  176.     }
  177.    
  178.    FreeMeAFloatArray(Count);
  179.    FreeMeAFloatArray(Mean);
  180.    FreeMeAFloatArray(Var);
  181.    FreeMeAFloatArray(InvDev);
  182.    
  183.    return S;
  184.   }
  185.  
  186.  
  187. /**************************************|****************************************
  188. Routine   : *FindPool
  189. Input  par: BitMap *Image, int D, int B, int delta, int keepdelta
  190. Output par: none
  191. Function  : Finds the pool structure, calls FindNodes recursively finding domain
  192.             and range pool for every resolution 
  193. ***************************************|***************************************/
  194.  
  195.  PoolStructure *FindPool(BitMap *Image,int FeatureDimensions, int GridRes,
  196.                          int TShadeEdge, int NSquare,int B,int delta)
  197.   {
  198.    if (NSquare>=0)
  199.     {
  200.      PoolStructure *Pool=GimmeAPoolStructure();
  201.      register unsigned int x,y,i,j;
  202.      register int Sum;
  203.      static int first=TRUE;
  204.      
  205.      if(first) /* build a sampled version of the original image */
  206.       {
  207.        first=FALSE;
  208.        FindPool_SampleImg=GimmeABitMap(Image->XSize>>1,Image->YSize>>1,
  209.                                        Image->ImgType);
  210.        for(x=0;x<Image->XSize;x+=2)      
  211.        for(y=0;y<Image->YSize;y+=2)        
  212.         {
  213.          Sum=0;
  214.          for(i=0;i<2;i++)          
  215.          for(j=0;j<2;j++)  Sum+=Image->Map[x+i][y+j];
  216.          FindPool_SampleImg->Map[x>>1][y>>1]=Sum>>2;
  217.         }
  218.       }
  219.      
  220.      Pool->SampledDomainBitmap=FindPool_SampleImg;
  221.      
  222.      vprintf(stderr,"\n   Range  ");
  223.      Pool->RangeNodes=FindNodes(Image,Pool,B,B,FeatureDimensions,(float)TShadeEdge,FALSE);
  224.      
  225.      Pool->Next=FindPool(Image,FeatureDimensions,GridRes,
  226.                          TShadeEdge,NSquare-1,B>>1,delta);
  227.      
  228.      
  229.      vprintf(stderr,"\n   Domain ");
  230.      Pool->DomainNodes=FindNodes(FindPool_SampleImg,Pool,B<<1,delta,
  231.                                  FeatureDimensions,(float)TShadeEdge,TRUE);
  232.      
  233.      Pool->DomainSpace=FindSpace(Pool,FeatureDimensions,GridRes,(float)TShadeEdge);
  234.      
  235.      return Pool;
  236.     }
  237.    else return (PoolStructure *)NULL;
  238.   }
  239.  
  240.